/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"

#include "ui组件构建结构.h"

#include <core/属性.h>

#include "框架/菜单管理.h"

#include "框架/屏幕.h"

#include "框架/工作区/节点视口/节点视口工作区.h"
#include "框架/工作区/3D工作区/3D视口工作区.h"
#include "框架/工作区/2D视口/2D视口工作区.h"
#include "框架/工作区/渲染器视口/渲染器视口工作区.h"
#include "框架/工作区/时间轴视口/时间轴视口工作区.h"
#include "框架/工作区/视频图像视口/视频图像工作区.h"
#include "框架/工作区/终端视口/终端工作区.h"
#include "框架/工作区/大纲/大纲工作区.h"


#include "框架/设置窗口/设置视口工作区.h"
#include "渲染/渲染.h"


typedef void(*fun_组件保存函数)(FILE* f, C_Widget* self, S_组件构建& ob);
typedef C_Widget*(*fun_组件加载函数)(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob);


static std::map<std::string, fun_组件保存函数> g组件保存函数;
static std::map<std::string, fun_组件加载函数> g组件加载函数;

static std::vector<S_Window*> g_工作窗口;
static std::vector<S_Window*> g_配置窗口;
static std::vector<S_Window*> g_文件对话框窗口;

static std::vector<S_Window*> g_销毁的工作窗口;





//========================= 主菜单 =============================
static void f_主菜单组件保存(FILE* f, C_Widget* self, S_组件构建& ob) {
	//C_菜单* 主菜单 = static_cast<C_菜单*>(self);
	//fwrite(&工作区页面->m_工作区类型, sizeof(E_工作区类型), 1, f);
	//ob.f_保存UI结构(f, self);
}

static C_Widget* f_主菜单组件加载(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	//fread(&type, sizeof(E_工作区类型), 1, f);
	auto* 主菜单 = f_界面构建_主菜单创建(ctx);
	//std::vector<C_Widget*> ws = ob.f_加载UI结构(f, ctx);
	return (C_Widget*)主菜单;
}






static void f_保存对话框(FILE* f, C_Widget* self, S_组件构建& ob) {
	f_file_保存字符串(f, u"对话框");
}

static C_Widget* f_加载对话框(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	std::u16string 对话框;
	对话框 = f_file_读取字符串(f);
	return S_框架::g_ui文件对话框;
}



//===================================== 页面 ==========================================
static C_Widget* f_工作区页面组件加载2(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	E_工作区类型 type{};
	bvec2 是否延展{};

	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
			下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, type);
			下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, 是否延展);
		}
		free(文件块.m_data);
	}


	auto* 工作区页面 = f_屏幕_create工作区页面(ctx, type);
	工作区页面->m_是否延展 = 是否延展;

	switch (type) {
		case e_3D视口:
			f_3D视口工作区_加载工作区状态(f, 工作区页面);
			break;
		case E_工作区类型::e_2D视口:
			//f_2D视口工作区_加载工作区状态(f, 工作区页面);
			break;
		case e_视频图像:
			//f_视频图像工作区_加载工作区状态(f, 工作区页面);
			break;
		case e_曲线视口:
			break;
		case e_时间轴:
			break;
		case e_节点视口:
			//f_物体节点工作区_加载工作区状态(f, 工作区页面);
			break;
		case e_材质节点视口:
			break;
		case e_渲染合成视口:
			//f_渲染器视口工作区_加载工作区状态(f, 工作区页面);
			break;
		case e_文本编辑视口:
			break;
		case e_大纲视口:
			f_大纲视图工作区_加载工作区状态(f, 工作区页面);
			break;
		case e_终端视口:
			f_终端视图工作区_加载工作区状态(f, 工作区页面);
			break;
		case e_模块视口:
			break;
		default:
			break;
	}

	return 工作区页面;
}

static void f_工作区页面组件保存2(FILE* f, C_Widget* self, S_组件构建& ob) {
	C_工作区页面* 工作区页面 = static_cast<C_工作区页面*>(self);
	{
		auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_界面布局, S_引擎配置::g_文件版本号);
		S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

		f_文件块_写数据块(块, 工作区页面->m_工作区类型);
		f_文件块_写数据块(块, 工作区页面->m_是否延展);

		f_file_保存文件块(f, 文件块, 块);
	}
	

	switch (工作区页面->m_工作区类型) {
		case E_工作区类型::e_3D视口:
			f_3D视口工作区_保存工作区状态(f, 工作区页面);
			break;
		case E_工作区类型::e_2D视口:
			//f_2D视口工作区_保存工作区状态(f, 工作区页面);
			break;
		case e_视频图像:
			//f_视频图像工作区_保存工作区状态(f, 工作区页面);
			break;
		case e_曲线视口:
			break;
		case e_时间轴:
			break;
		case e_节点视口:
			//f_物体节点工作区_保存工作区状态(f, 工作区页面);
			break;
		case e_材质节点视口:
			break;
		case e_渲染合成视口:
			//f_渲染器视口工作区_保存工作区状态(f, 工作区页面);
			break;
		case e_文本编辑视口:
			break;
		case e_大纲视口:
			f_大纲视图工作区_保存工作区状态(f, 工作区页面);
			break;
		case e_终端视口:
			f_终端视图工作区_保存工作区状态(f, 工作区页面);
			break;
		default:
			break;
	}
	//ob.f_保存UI结构(f, self->m_子部件);
}

//===================================== 工作区 ==========================================
static C_Widget* f_工作区组件加载(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	E_方向 方向 = E_方向::e_纵向;

	{
		S_文件块 文件块 = f_file_读取文件块(f);
		if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
			const uint8* 下一次读取数据指针 = 文件块.m_data;

			if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
				下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, 方向);
			}
		}
		free(文件块.m_data);
	}
	
	auto* 工作区 = f_屏幕_创建工作区(ctx, 方向);
	std::vector<C_Widget*> ws = ob.f_加载UI结构2(f, ctx);
	for (auto& w : ws) {
		f_屏幕_添加工作区页面(工作区, static_cast<C_工作区页面*>(w));
	}
	return 工作区;
}

static void f_工作区组件保存(FILE* f, C_Widget* self, S_组件构建& ob) {
	{
		auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_界面布局, S_引擎配置::g_文件版本号);
		S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

		E_方向 方向 = f_ui_get多页面标签方向(self);
		f_文件块_写数据块(块, 方向);

		f_file_保存文件块(f, 文件块, 块);
	}
	
	auto ws = f_ui_get多页面所有页面(self);
	ob.f_保存UI结构2(f, ws);

}




//========================== 分割窗口 ==========================
static C_Widget* f_分割窗口组件加载(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	E_方向 方向 = E_方向::e_横向;
	bvec2 是否延展 = {true, true};
	std::vector<float32> 分割比;
	{
		S_文件块 文件块 = f_file_读取文件块(f);
		if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
			const uint8* 下一次读取数据指针 = 文件块.m_data;

			if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
				下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, 方向);
				下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, 是否延展);

				f_文件块_读序列数据块(下一次读取数据指针, 分割比, false);
			}
		}
		free(文件块.m_data);
	}
	
	std::vector<C_Widget*> ws = ob.f_加载UI结构2(f, ctx);
	auto* 分割窗口 = f_ui_创建分割框(ws, 方向, 分割比, ctx);
	分割窗口->m_是否延展 = 是否延展;
	return 分割窗口;
}

static void f_分割窗口组件保存(FILE* f, C_Widget* self, S_组件构建& ob) {
	{
		auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_界面布局, S_引擎配置::g_文件版本号);
		S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

		E_方向 方向 = f_ui_get分割框排列方向(self);
		std::vector<float32> 分割比 = f_ui_get分割框分割比例(self);
		f_文件块_写数据块(块, 方向);
		f_文件块_写数据块(块, self->m_是否延展);
		f_文件块_写序列数据块(块, 分割比, false);

		f_file_保存文件块(f, 文件块, 块);
	}
	
	auto ws = f_ui_get分割框页面组件(self);
	ob.f_保存UI结构2(f, ws);
}


//========================= 主菜单 =============================
static C_Widget* f_主菜单组件加载2(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	auto* 主菜单 = f_界面构建_主菜单创建(ctx);
	
	{
		S_文件块 文件块 = f_file_读取文件块(f);
		if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
			const uint8* 下一次读取数据指针 = 文件块.m_data;

			if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_8, S_引擎配置::g_文件版本号)) {
				//下一次读取数据指针 = f_文件块_取数据块(方式, 下一次读取数据指针);
			}
		}
		free(文件块.m_data);
	}
	return (C_Widget*)主菜单;
}

static void f_主菜单组件保存2(FILE* f, C_Widget* self, S_组件构建& ob) {
	C_菜单* 主菜单 = (C_菜单*)self;
	
	{
		auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_界面布局, S_引擎配置::g_文件版本号);
		S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

		f_文件块_写数据块(块, self->m_布局方式);

		f_file_保存文件块(f, 文件块, 块);
	}
}




static C_Widget* f_加载对话框2(FILE* f, S_UI渲染环境& ctx, S_组件构建& ob) {
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
			std::u16string 对话框;
			下一次读取数据指针 = f_解宽字符串(对话框, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);

	return S_框架::g_ui文件对话框;
}

static void f_保存对话框2(FILE* f, C_Widget* self, S_组件构建& ob) {
	auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_界面布局, S_引擎配置::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	std::u16string 对话框 = u"对话框";
	f_包宽字符串(块, 对话框);

	f_file_保存文件块(f, 文件块, 块);
}




S_组件构建::S_组件构建() {
	static bool 以初始化函数指针 = false;
	if (!以初始化函数指针) {
		
		g组件保存函数["工作区页面"] = f_工作区页面组件保存2;
		g组件加载函数["工作区页面"] = f_工作区页面组件加载2;

		g组件保存函数["工作区"] = f_工作区组件保存;
		g组件加载函数["工作区"] = f_工作区组件加载;

		g组件保存函数["分割框"] = f_分割窗口组件保存;
		g组件加载函数["分割框"] = f_分割窗口组件加载;

		g组件保存函数["主菜单"] = f_主菜单组件保存2;
		g组件加载函数["主菜单"] = f_主菜单组件加载2;

		//g组件保存函数[DEF_WIDGET_根布局] = f_保存根分割布局2;
		//g组件加载函数[DEF_WIDGET_根布局] = f_加载根分割布局2;

		g组件保存函数["对话框"] = f_保存对话框2;
		g组件加载函数["对话框"] = f_加载对话框2;

		以初始化函数指针 = true;
	}
	
}

std::vector<C_Widget*> S_组件构建::f_加载UI结构2(FILE* f, S_UI渲染环境& ctx) {
	std::vector<C_Widget*> ws;

	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
			uint32 num = 0;
			下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, num);

			std::vector<std::string> 工作区类型名称;
			for (uint32 i = 0; i < num; ++i) {
				std::string 名称;
				下一次读取数据指针 = f_解字符串(名称, 下一次读取数据指针);
				工作区类型名称.push_back(名称);
			}

			for (auto& name : 工作区类型名称) {
				if (g组件加载函数.find(name) != g组件加载函数.end()) {
					C_Widget* w = g组件加载函数[name](f, ctx, *this);
					ws.push_back(w);
				}
			}
		}
	}

	return ws;
}


void S_组件构建::f_保存UI结构2(FILE* f, const std::vector<C_Widget*>& ws) {
	S_文件块 文件块;
	文件块.m_块类型 = E_节点工程文件块类型::e_工程文件块_界面布局;
	文件块.m_版本号 = S_引擎配置::g_文件版本号;

	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));
	uint32 num = ws.size();
	f_文件块_写数据块(块, num);
	
	for (uint32 i = 0; i < num; ++i) {
		if (g组件保存函数.find(ws[i]->m_TypeName) != g组件保存函数.end()) {
			f_包字符串(块, ws[i]->m_TypeName);
		}
	}
	f_file_保存文件块(f, 文件块, 块);

	for (uint32 i = 0; i < num; ++i) {
		if (g组件保存函数.find(ws[i]->m_TypeName) != g组件保存函数.end()) {
			g组件保存函数[ws[i]->m_TypeName](f, ws[i], *this);
		}
	}
}




void S_组件构建::f_保存界面框架(FILE* f) {
	S_文件块 文件块;
	文件块.m_块类型 = E_节点工程文件块类型::e_工程文件块_界面布局;
	文件块.m_版本号 = S_引擎配置::g_文件版本号;
	
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));
	uint32 num = S_框架::g_主窗口.size();
	f_文件块_写数据块(块, num);

	for (auto& window : S_框架::g_主窗口) {
		f_文件块_写数据块(块, uint64(((C_Widget*)window)->m_Type));
	}
	f_file_保存文件块(f, 文件块, 块);

	
	for (auto& window : S_框架::g_主窗口) {
		switch (((C_Widget*)window)->m_Type) {
			case E_WidgetType::t_窗口: {
				auto ws = f_window_getUI管理(window)->m_Root->m_子组件;
				ws.erase(ws.begin());
				f_保存UI结构2(f, ws);
				break;
			}
		}
	}
	
}

void S_组件构建::f_加载界面框架(FILE* f) {
	
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_界面布局) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		uint32 num = 0;
		下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, num);

		for (uint32 i = 0; i < num; ++i) {
			uint64 窗口类型 = 0;
			下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, 窗口类型);

			switch (窗口类型) {
				case E_WidgetType::t_窗口: {
					S_Window* window = f_界面_构建工作窗口(false);

					std::vector<C_Widget*> ws;
					ws = f_加载UI结构2(f, *f_window_getUI环境(window));
					f_widget_push待添加部件(f_window_getUI管理(window)->m_Root, ws.data(), ws.size(), 1, false);

					break;
				}
				default:
					break;
			}
		}
	}

}





S_Window* f_界面_创建文件对话框() {
	std::string 默认路径 = "I:/TEMP/";
	if (f_file_文件是否存在(默认路径) == false) {
		默认路径 = f_str_u16_to_u8(S_引擎配置::g_工程文件临时路径);
	}

	S_Window* window = S_框架::f_创建窗口到列队({ 640, 420 }, false);
	((C_Widget*)(window))->m_Type = E_WidgetType::t_文件对话框;

	S_框架::g_ui文件对话框 = f_ui_创建文件对话框(*f_window_getUI环境(window), 默认路径);
	S_框架::m_工作区视口渲染层ID分配.f_置组件渲染层(S_框架::g_ui文件对话框);

	std::filesystem::path 最近打开文件 = S_引擎配置::g_配置文件路径;
	最近打开文件 += "/MBT3D/最近打开文件.txt";
	FILE* f = fopen(最近打开文件.string().c_str(), "rb");
	if (f) {
		S_框架::g_最近打开文件 = f_file_读取字符串组(f);
		fclose(f);
	}
	f_ui_添加临时文件路径(S_框架::g_ui文件对话框, S_框架::g_最近打开文件);
	f_window_安装UI(window, S_框架::g_ui文件对话框);

	
	g_文件对话框窗口.push_back(window);
	return window;
}

S_Window* f_界面_创建配置窗口() {
	auto ui_设置窗口根组件 = f_ui_创建根部件({ 0.2, 0.2 }, { 0.8, 0.8 }, E_布局方式::e_VBOX布局);
	S_框架::m_工作区视口渲染层ID分配.f_置组件渲染层(ui_设置窗口根组件);

	S_Window* window = S_框架::f_创建窗口到列队({ 640, 420 });
	f_window_安装UI(window, ui_设置窗口根组件);
	
	auto* 设置视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_设置视口, E_方向::e_纵向);
	ui_设置窗口根组件->f_添加子组件(设置视口);
	f_window_set显示(window, false);

	g_配置窗口.push_back(window);
	return window;
}

S_Window* f_界面_创建工作窗口(bool 创建默认工作区) {
	S_Window* window;

	if (g_销毁的工作窗口.empty()) {
		window = S_框架::f_创建窗口到列队({ 1024, 576 });
		f_屏幕_创建窗口根布局(window, true);
	}
	else {
		window = g_销毁的工作窗口.back();
		f_widget_remove区间子组件(f_window_getUI管理(window)->m_Root, 1, -1, false);

		g_销毁的工作窗口.pop_back();
	}

	if (创建默认工作区) {
		f_界面_创建默认工作区(f_window_getUI管理(window)->m_Root, window);
	}
	f_window_getUI管理(window)->f_重置事件();

	g_工作窗口.push_back(window);
	return window;
}

void f_界面_重置工作窗口() {
	if (g_工作窗口.size()) {
		auto it = g_工作窗口.begin();
		for (++it; it != g_工作窗口.end(); ++it) {
			f_window_销毁(*it);
		}

		g_销毁的工作窗口 = {*g_工作窗口.begin()};
		g_工作窗口.clear();
	}
	//f_界面_创建工作窗口(创建默认工作区);
}

S_Window* f_界面_构建工作窗口(bool 创建默认工作区) {
	S_Window* window = f_界面_创建工作窗口(创建默认工作区);
	return window;
}






void f_界面_创建默认工作区(C_Widget* 根布局, S_Window* window) {
	f_widget_remove区间子组件(根布局, 1, -1, false);


	auto* 屏幕左 = f_屏幕_创建工作区(*f_window_getUI环境(window));
	auto* 屏幕右 = f_屏幕_创建工作区(*f_window_getUI环境(window));
	屏幕左->m_WName = u"屏幕左";
	屏幕右->m_WName = u"屏幕右";
	{
		auto* ui工作区_3D视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_3D视口);
		auto* ui工作区_2D视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_2D视口);
		ui工作区_3D视口->m_WName = u"3D视口";
		ui工作区_2D视口->m_WName = u"2D视口";

		auto* ui工作区_大纲视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_大纲视口);
		auto* ui工作区_模块视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_终端视口);
		ui工作区_大纲视口->m_WName = u"大纲视口";
		ui工作区_模块视口->m_WName = u"模块视口";

		f_屏幕_添加工作区页面(屏幕左, ui工作区_3D视口);
		f_屏幕_添加工作区页面(屏幕左, ui工作区_2D视口);

		f_屏幕_添加工作区页面(屏幕右, ui工作区_大纲视口);
		f_屏幕_添加工作区页面(屏幕右, ui工作区_模块视口);
	}


	auto* 屏幕节点区 = f_屏幕_创建工作区(*f_window_getUI环境(window));
	auto* 屏幕时间线 = f_屏幕_创建工作区(*f_window_getUI环境(window));
	屏幕节点区->m_WName = u"屏幕节点区";
	屏幕时间线->m_WName = u"屏幕时间线";
	{
		{
			auto* ui工作区_节点视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_节点视口);
			f_屏幕_添加工作区页面(屏幕节点区, ui工作区_节点视口);
		}
		{
			auto* ui工作区_时间视口 = f_屏幕_create工作区页面(*f_window_getUI环境(window), E_工作区类型::e_时间轴);
			f_屏幕_添加工作区页面(屏幕时间线, ui工作区_时间视口);
		}
	}
	//auto* ui上分割框 = f_ui_创建分割框({ 屏幕左 , 屏幕右 }, E_方向::e_纵向, { 0.7f, 1.0f }, *f_window_getUI环境(window));


	{
		auto* ui上下分割框 = f_ui_创建分割框( { 
			f_ui_创建分割框({ 屏幕左 , 屏幕右 }, E_方向::e_纵向, { 0.7f, 1.0f }, *f_window_getUI环境(window)) ,
			屏幕节点区,
			屏幕时间线
		}, 
		E_方向::e_横向, { 0.5f, 0.9f, 1.0f }, * f_window_getUI环境(window));

		ui上下分割框->m_WName = u"分割框 节点区 时间线";
		ui上下分割框->m_是否延展 = { true, true };
		根布局->f_添加子组件(ui上下分割框);
	}
}








